package com.cdn.client.netty.utils;

import org.springframework.stereotype.Component;
import oshi.SystemInfo;
import oshi.hardware.CentralProcessor;
import oshi.hardware.GlobalMemory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigDecimal;

@Component
public class NodeResourceUtil {

    private static SystemInfo systemInfo = new SystemInfo();

    private static long previousBytes = 0L;  // 上一次读取的字节数

    /**
     * 获取 CPU 使用率
     * 使用 getSystemCpuLoadBetweenTicks(long[] ticks) 计算 CPU 使用率
     */
    public static BigDecimal getCpuUsage() {
        CentralProcessor processor = systemInfo.getHardware().getProcessor();
        long[] prevTicks = processor.getSystemCpuLoadTicks();  // 获取初始 ticks
        try {
            Thread.sleep(30000);  // 暂停一秒钟，以便重新计算
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        // 计算 CPU 使用率（1秒内的）
        double cpuUsage = processor.getSystemCpuLoadBetweenTicks(prevTicks);
        return new BigDecimal(cpuUsage * 100).setScale(2, BigDecimal.ROUND_HALF_UP);  // 转换为百分比
    }

    /**
     * 获取内存使用情况
     */
    public static BigDecimal getMemoryUsage() {
        GlobalMemory memory = systemInfo.getHardware().getMemory();
        long totalMemory = memory.getTotal(); // 总内存
        long availableMemory = memory.getAvailable(); // 可用内存
        long usedMemory = totalMemory - availableMemory; // 已使用内存
        double usedMemoryInGB = usedMemory / (1024.0 * 1024.0 * 1024.0); // 转换为 GB
        return new BigDecimal(usedMemoryInGB).setScale(2, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 获取实时下行带宽
     * 通过执行 Linux 上的 netstat 命令获取网络流量数据
     */
    public static Long getDownstreamBandwidth() {
        long currentBytes = 0L;

        try {
            // 读取 /proc/net/dev 文件获取网络接口的流量信息
            Process process = Runtime.getRuntime().exec("cat /proc/net/dev");
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;

            // 跳过前两行标题
            while ((line = reader.readLine()) != null) {
                if (line.contains("Inter-") || line.trim().isEmpty()) {
                    continue;
                }

                // 获取每个网络接口的信息（以空格为分隔符）
                String[] parts = line.trim().split("\\s+");
                if (parts.length >= 17) {
                    try {
                        // 获取接收字节数（bytes）
                        currentBytes = Long.parseLong(parts[1]);  // 第二列是接收字节数
                    } catch (NumberFormatException e) {
                        System.err.println("无法解析接收字节数: " + parts[1]);
                    }
                }
            }

            // 计算带宽增量（字节数增量）
            long bandwidth = currentBytes - previousBytes;
            previousBytes = currentBytes;  // 更新 previousBytes

            return bandwidth;

        } catch (IOException e) {
            e.printStackTrace();
        }

        return 0L;  // 如果出错，返回 0
    }

    /**
     * 获取活动连接数
     * 使用系统命令（如 netstat）获取当前活动的网络连接数
     */
    public static Integer getConnectionCount() {
        String command = "netstat -an | grep ESTABLISHED | wc -l";  // 获取 ESTABLISHED 状态的连接数
        Process process = null;
        BufferedReader reader = null;
        try {
            // 执行命令
            process = Runtime.getRuntime().exec(command);
            reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String output = reader.readLine();

            // 清理输出，去掉非数字字符
            if (output != null && !output.trim().isEmpty()) {
                return Integer.parseInt(output.trim());  // 转换为整数
            }
        } catch (IOException | NumberFormatException e) {
            e.printStackTrace();
        } finally {
            // 确保资源被关闭
            try {
                if (reader != null) {
                    reader.close();
                }
                if (process != null) {
                    process.waitFor();  // 等待进程结束
                }
            } catch (IOException | InterruptedException e) {
                e.printStackTrace();
            }
        }

        return 0;  // 默认返回 0
    }

    /**
     * 获取系统负载
     * 获取 1 分钟的系统负载
     */
    public static BigDecimal getSystemLoad() {
        CentralProcessor processor = systemInfo.getHardware().getProcessor();
        double[] loadAverage = processor.getSystemLoadAverage(3); // 获取 1、5、15 分钟的负载
        double load = loadAverage[0];  // 获取 1 分钟的负载平均值
        return new BigDecimal(load).setScale(2, BigDecimal.ROUND_HALF_UP);
    }

}
